home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / cgi.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  21KB  |  907 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __version__ = '2.6'
  5. from operator import attrgetter
  6. import sys
  7. import os
  8. import urllib
  9. import mimetools
  10. import rfc822
  11. import UserDict
  12.  
  13. try:
  14.     from cStringIO import StringIO
  15. except ImportError:
  16.     from StringIO import StringIO
  17.  
  18. __all__ = [
  19.     'MiniFieldStorage',
  20.     'FieldStorage',
  21.     'FormContentDict',
  22.     'SvFormContentDict',
  23.     'InterpFormContentDict',
  24.     'FormContent',
  25.     'parse',
  26.     'parse_qs',
  27.     'parse_qsl',
  28.     'parse_multipart',
  29.     'parse_header',
  30.     'print_exception',
  31.     'print_environ',
  32.     'print_form',
  33.     'print_directory',
  34.     'print_arguments',
  35.     'print_environ_usage',
  36.     'escape']
  37. logfile = ''
  38. logfp = None
  39.  
  40. def initlog(*allargs):
  41.     global logfp, log
  42.     if logfile and not logfp:
  43.         
  44.         try:
  45.             logfp = open(logfile, 'a')
  46.         except IOError:
  47.             pass
  48.         except:
  49.             None<EXCEPTION MATCH>IOError
  50.         
  51.  
  52.     None<EXCEPTION MATCH>IOError
  53.     if not logfp:
  54.         log = nolog
  55.     else:
  56.         log = dolog
  57.     log(*allargs)
  58.  
  59.  
  60. def dolog(fmt, *args):
  61.     logfp.write(fmt % args + '\n')
  62.  
  63.  
  64. def nolog(*allargs):
  65.     pass
  66.  
  67. log = initlog
  68. maxlen = 0
  69.  
  70. def parse(fp = None, environ = os.environ, keep_blank_values = 0, strict_parsing = 0):
  71.     if fp is None:
  72.         fp = sys.stdin
  73.     
  74.     if 'REQUEST_METHOD' not in environ:
  75.         environ['REQUEST_METHOD'] = 'GET'
  76.     
  77.     if environ['REQUEST_METHOD'] == 'POST':
  78.         (ctype, pdict) = parse_header(environ['CONTENT_TYPE'])
  79.         if ctype == 'multipart/form-data':
  80.             return parse_multipart(fp, pdict)
  81.         elif ctype == 'application/x-www-form-urlencoded':
  82.             clength = int(environ['CONTENT_LENGTH'])
  83.             if maxlen and clength > maxlen:
  84.                 raise ValueError, 'Maximum content length exceeded'
  85.             
  86.             qs = fp.read(clength)
  87.         else:
  88.             qs = ''
  89.         if 'QUERY_STRING' in environ:
  90.             if qs:
  91.                 qs = qs + '&'
  92.             
  93.             qs = qs + environ['QUERY_STRING']
  94.         elif sys.argv[1:]:
  95.             if qs:
  96.                 qs = qs + '&'
  97.             
  98.             qs = qs + sys.argv[1]
  99.         
  100.         environ['QUERY_STRING'] = qs
  101.     elif 'QUERY_STRING' in environ:
  102.         qs = environ['QUERY_STRING']
  103.     elif sys.argv[1:]:
  104.         qs = sys.argv[1]
  105.     else:
  106.         qs = ''
  107.     environ['QUERY_STRING'] = qs
  108.     return parse_qs(qs, keep_blank_values, strict_parsing)
  109.  
  110.  
  111. def parse_qs(qs, keep_blank_values = 0, strict_parsing = 0):
  112.     dict = { }
  113.     for name, value in parse_qsl(qs, keep_blank_values, strict_parsing):
  114.         if name in dict:
  115.             dict[name].append(value)
  116.             continue
  117.         dict[name] = [
  118.             value]
  119.     
  120.     return dict
  121.  
  122.  
  123. def parse_qsl(qs, keep_blank_values = 0, strict_parsing = 0):
  124.     pairs = [ s2 for s1 in qs.split('&') for s2 in s1.split(';') ]
  125.     r = []
  126.     for name_value in pairs:
  127.         nv = name_value.split('=', 1)
  128.         if len(nv) != 2:
  129.             if strict_parsing:
  130.                 raise ValueError, 'bad query field: %r' % (name_value,)
  131.             
  132.             if keep_blank_values:
  133.                 nv.append('')
  134.             
  135.         
  136.         if len(nv[1]) or keep_blank_values:
  137.             name = urllib.unquote(nv[0].replace('+', ' '))
  138.             value = urllib.unquote(nv[1].replace('+', ' '))
  139.             r.append((name, value))
  140.             continue
  141.     
  142.     return r
  143.  
  144.  
  145. def parse_multipart(fp, pdict):
  146.     boundary = ''
  147.     if 'boundary' in pdict:
  148.         boundary = pdict['boundary']
  149.     
  150.     if not valid_boundary(boundary):
  151.         raise ValueError, 'Invalid boundary in multipart form: %r' % (boundary,)
  152.     
  153.     nextpart = '--' + boundary
  154.     lastpart = '--' + boundary + '--'
  155.     partdict = { }
  156.     terminator = ''
  157.     while terminator != lastpart:
  158.         bytes = -1
  159.         data = None
  160.         if terminator:
  161.             headers = mimetools.Message(fp)
  162.             clength = headers.getheader('content-length')
  163.             if clength:
  164.                 
  165.                 try:
  166.                     bytes = int(clength)
  167.                 except ValueError:
  168.                     pass
  169.                 except:
  170.                     None<EXCEPTION MATCH>ValueError
  171.                 
  172.  
  173.             None<EXCEPTION MATCH>ValueError
  174.             if bytes > 0:
  175.                 if maxlen and bytes > maxlen:
  176.                     raise ValueError, 'Maximum content length exceeded'
  177.                 
  178.                 data = fp.read(bytes)
  179.             else:
  180.                 data = ''
  181.         
  182.         lines = []
  183.         while None:
  184.             line = fp.readline()
  185.             if not line:
  186.                 terminator = lastpart
  187.                 break
  188.             
  189.             if line[:2] == '--':
  190.                 terminator = line.strip()
  191.                 if terminator in (nextpart, lastpart):
  192.                     break
  193.                 
  194.             
  195.             continue
  196.             if data is None:
  197.                 continue
  198.             
  199.         if bytes < 0:
  200.             if lines:
  201.                 line = lines[-1]
  202.                 if line[-2:] == '\r\n':
  203.                     line = line[:-2]
  204.                 elif line[-1:] == '\n':
  205.                     line = line[:-1]
  206.                 
  207.                 lines[-1] = line
  208.                 data = ''.join(lines)
  209.             
  210.         
  211.         line = headers['content-disposition']
  212.         if not line:
  213.             continue
  214.         
  215.         (key, params) = parse_header(line)
  216.         if key != 'form-data':
  217.             continue
  218.         
  219.         if 'name' in params:
  220.             name = params['name']
  221.         
  222.         if name in partdict:
  223.             partdict[name].append(data)
  224.             continue
  225.         'name' in params
  226.         partdict[name] = [
  227.             data]
  228.     return partdict
  229.  
  230.  
  231. def parse_header(line):
  232.     plist = [ x.strip() for x in line.split(';') ]
  233.     key = plist.pop(0).lower()
  234.     pdict = { }
  235.     for p in plist:
  236.         i = p.find('=')
  237.         if i >= 0:
  238.             name = p[:i].strip().lower()
  239.             value = p[i + 1:].strip()
  240.             if len(value) >= 2:
  241.                 if value[-1] == value[-1]:
  242.                     pass
  243.                 elif value[-1] == '"':
  244.                     value = value[1:-1]
  245.                     value = value.replace('\\\\', '\\').replace('\\"', '"')
  246.                 
  247.             pdict[name] = value
  248.             continue
  249.         []
  250.     
  251.     return (key, pdict)
  252.  
  253.  
  254. class MiniFieldStorage:
  255.     filename = None
  256.     list = None
  257.     type = None
  258.     file = None
  259.     type_options = { }
  260.     disposition = None
  261.     disposition_options = { }
  262.     headers = { }
  263.     
  264.     def __init__(self, name, value):
  265.         self.name = name
  266.         self.value = value
  267.  
  268.     
  269.     def __repr__(self):
  270.         return 'MiniFieldStorage(%r, %r)' % (self.name, self.value)
  271.  
  272.  
  273.  
  274. class FieldStorage:
  275.     
  276.     def __init__(self, fp = None, headers = None, outerboundary = '', environ = os.environ, keep_blank_values = 0, strict_parsing = 0):
  277.         method = 'GET'
  278.         self.keep_blank_values = keep_blank_values
  279.         self.strict_parsing = strict_parsing
  280.         if 'REQUEST_METHOD' in environ:
  281.             method = environ['REQUEST_METHOD'].upper()
  282.         
  283.         if method == 'GET' or method == 'HEAD':
  284.             if 'QUERY_STRING' in environ:
  285.                 qs = environ['QUERY_STRING']
  286.             elif sys.argv[1:]:
  287.                 qs = sys.argv[1]
  288.             else:
  289.                 qs = ''
  290.             fp = StringIO(qs)
  291.             if headers is None:
  292.                 headers = {
  293.                     'content-type': 'application/x-www-form-urlencoded' }
  294.             
  295.         
  296.         if headers is None:
  297.             headers = { }
  298.             if method == 'POST':
  299.                 headers['content-type'] = 'application/x-www-form-urlencoded'
  300.             
  301.             if 'CONTENT_TYPE' in environ:
  302.                 headers['content-type'] = environ['CONTENT_TYPE']
  303.             
  304.             if 'CONTENT_LENGTH' in environ:
  305.                 headers['content-length'] = environ['CONTENT_LENGTH']
  306.             
  307.         
  308.         if not fp:
  309.             pass
  310.         self.fp = sys.stdin
  311.         self.headers = headers
  312.         self.outerboundary = outerboundary
  313.         cdisp = ''
  314.         pdict = { }
  315.         if 'content-disposition' in self.headers:
  316.             (cdisp, pdict) = parse_header(self.headers['content-disposition'])
  317.         
  318.         self.disposition = cdisp
  319.         self.disposition_options = pdict
  320.         self.name = None
  321.         if 'name' in pdict:
  322.             self.name = pdict['name']
  323.         
  324.         self.filename = None
  325.         if 'filename' in pdict:
  326.             self.filename = pdict['filename']
  327.         
  328.         if 'content-type' in self.headers:
  329.             (ctype, pdict) = parse_header(self.headers['content-type'])
  330.         elif self.outerboundary or method != 'POST':
  331.             ctype = 'text/plain'
  332.             pdict = { }
  333.         else:
  334.             ctype = 'application/x-www-form-urlencoded'
  335.             pdict = { }
  336.         self.type = ctype
  337.         self.type_options = pdict
  338.         self.innerboundary = ''
  339.         if 'boundary' in pdict:
  340.             self.innerboundary = pdict['boundary']
  341.         
  342.         clen = -1
  343.         if 'content-length' in self.headers:
  344.             
  345.             try:
  346.                 clen = int(self.headers['content-length'])
  347.             except ValueError:
  348.                 pass
  349.  
  350.             if maxlen and clen > maxlen:
  351.                 raise ValueError, 'Maximum content length exceeded'
  352.             
  353.         
  354.         self.length = clen
  355.         self.list = None
  356.         self.file = None
  357.         self.done = 0
  358.         if ctype == 'application/x-www-form-urlencoded':
  359.             self.read_urlencoded()
  360.         elif ctype[:10] == 'multipart/':
  361.             self.read_multi(environ, keep_blank_values, strict_parsing)
  362.         else:
  363.             self.read_single()
  364.  
  365.     
  366.     def __repr__(self):
  367.         return 'FieldStorage(%r, %r, %r)' % (self.name, self.filename, self.value)
  368.  
  369.     
  370.     def __iter__(self):
  371.         return iter(self.keys())
  372.  
  373.     
  374.     def __getattr__(self, name):
  375.         if name != 'value':
  376.             raise AttributeError, name
  377.         
  378.         if self.file:
  379.             self.file.seek(0)
  380.             value = self.file.read()
  381.             self.file.seek(0)
  382.         elif self.list is not None:
  383.             value = self.list
  384.         else:
  385.             value = None
  386.         return value
  387.  
  388.     
  389.     def __getitem__(self, key):
  390.         if self.list is None:
  391.             raise TypeError, 'not indexable'
  392.         
  393.         found = []
  394.         for item in self.list:
  395.             if item.name == key:
  396.                 found.append(item)
  397.                 continue
  398.         
  399.         if not found:
  400.             raise KeyError, key
  401.         
  402.         if len(found) == 1:
  403.             return found[0]
  404.         else:
  405.             return found
  406.  
  407.     
  408.     def getvalue(self, key, default = None):
  409.         if key in self:
  410.             value = self[key]
  411.             if type(value) is type([]):
  412.                 return map(attrgetter('value'), value)
  413.             else:
  414.                 return value.value
  415.         else:
  416.             return default
  417.  
  418.     
  419.     def getfirst(self, key, default = None):
  420.         if key in self:
  421.             value = self[key]
  422.             if type(value) is type([]):
  423.                 return value[0].value
  424.             else:
  425.                 return value.value
  426.         else:
  427.             return default
  428.  
  429.     
  430.     def getlist(self, key):
  431.         if key in self:
  432.             value = self[key]
  433.             if type(value) is type([]):
  434.                 return map(attrgetter('value'), value)
  435.             else:
  436.                 return [
  437.                     value.value]
  438.         else:
  439.             return []
  440.  
  441.     
  442.     def keys(self):
  443.         if self.list is None:
  444.             raise TypeError, 'not indexable'
  445.         
  446.         keys = []
  447.         for item in self.list:
  448.             if item.name not in keys:
  449.                 keys.append(item.name)
  450.                 continue
  451.         
  452.         return keys
  453.  
  454.     
  455.     def has_key(self, key):
  456.         if self.list is None:
  457.             raise TypeError, 'not indexable'
  458.         
  459.         for item in self.list:
  460.             if item.name == key:
  461.                 return True
  462.                 continue
  463.         
  464.         return False
  465.  
  466.     
  467.     def __contains__(self, key):
  468.         if self.list is None:
  469.             raise TypeError, 'not indexable'
  470.         
  471.         for item in self.list:
  472.             if item.name == key:
  473.                 return True
  474.                 continue
  475.         
  476.         return False
  477.  
  478.     
  479.     def __len__(self):
  480.         return len(self.keys())
  481.  
  482.     
  483.     def read_urlencoded(self):
  484.         qs = self.fp.read(self.length)
  485.         self.list = list = []
  486.         for key, value in parse_qsl(qs, self.keep_blank_values, self.strict_parsing):
  487.             list.append(MiniFieldStorage(key, value))
  488.         
  489.         self.skip_lines()
  490.  
  491.     FieldStorageClass = None
  492.     
  493.     def read_multi(self, environ, keep_blank_values, strict_parsing):
  494.         ib = self.innerboundary
  495.         if not valid_boundary(ib):
  496.             raise ValueError, 'Invalid boundary in multipart form: %r' % (ib,)
  497.         
  498.         self.list = []
  499.         if not self.FieldStorageClass:
  500.             pass
  501.         klass = self.__class__
  502.         part = klass(self.fp, { }, ib, environ, keep_blank_values, strict_parsing)
  503.         while not part.done:
  504.             headers = rfc822.Message(self.fp)
  505.             part = klass(self.fp, headers, ib, environ, keep_blank_values, strict_parsing)
  506.             self.list.append(part)
  507.         self.skip_lines()
  508.  
  509.     
  510.     def read_single(self):
  511.         if self.length >= 0:
  512.             self.read_binary()
  513.             self.skip_lines()
  514.         else:
  515.             self.read_lines()
  516.         self.file.seek(0)
  517.  
  518.     bufsize = 8192
  519.     
  520.     def read_binary(self):
  521.         self.file = self.make_file('b')
  522.         todo = self.length
  523.         if todo >= 0:
  524.             while todo > 0:
  525.                 data = self.fp.read(min(todo, self.bufsize))
  526.                 if not data:
  527.                     self.done = -1
  528.                     break
  529.                 
  530.                 self.file.write(data)
  531.                 todo = todo - len(data)
  532.         
  533.  
  534.     
  535.     def read_lines(self):
  536.         self.file = self._FieldStorage__file = StringIO()
  537.         if self.outerboundary:
  538.             self.read_lines_to_outerboundary()
  539.         else:
  540.             self.read_lines_to_eof()
  541.  
  542.     
  543.     def __write(self, line):
  544.         if self._FieldStorage__file is not None:
  545.             if self._FieldStorage__file.tell() + len(line) > 1000:
  546.                 self.file = self.make_file('')
  547.                 self.file.write(self._FieldStorage__file.getvalue())
  548.                 self._FieldStorage__file = None
  549.             
  550.         
  551.         self.file.write(line)
  552.  
  553.     
  554.     def read_lines_to_eof(self):
  555.         while None:
  556.             line = self.fp.readline(65536)
  557.             if not line:
  558.                 self.done = -1
  559.                 break
  560.             
  561.             continue
  562.             return None
  563.  
  564.     
  565.     def read_lines_to_outerboundary(self):
  566.         next = '--' + self.outerboundary
  567.         last = next + '--'
  568.         delim = ''
  569.         last_line_lfend = True
  570.         while None:
  571.             line = self.fp.readline(65536)
  572.             if not line:
  573.                 self.done = -1
  574.                 break
  575.             
  576.             if line[:2] == '--' and last_line_lfend:
  577.                 strippedline = line.strip()
  578.                 if strippedline == next:
  579.                     break
  580.                 
  581.                 if strippedline == last:
  582.                     self.done = 1
  583.                     break
  584.                 
  585.             
  586.             odelim = delim
  587.             if line[-2:] == '\r\n':
  588.                 delim = '\r\n'
  589.                 line = line[:-2]
  590.                 last_line_lfend = True
  591.             elif line[-1] == '\n':
  592.                 delim = '\n'
  593.                 line = line[:-1]
  594.                 last_line_lfend = True
  595.             else:
  596.                 delim = ''
  597.                 last_line_lfend = False
  598.             continue
  599.             return None
  600.  
  601.     
  602.     def skip_lines(self):
  603.         if not (self.outerboundary) or self.done:
  604.             return None
  605.         
  606.         next = '--' + self.outerboundary
  607.         last = next + '--'
  608.         last_line_lfend = True
  609.         while None:
  610.             line = self.fp.readline(65536)
  611.             if not line:
  612.                 self.done = -1
  613.                 break
  614.             
  615.             if line[:2] == '--' and last_line_lfend:
  616.                 strippedline = line.strip()
  617.                 if strippedline == next:
  618.                     break
  619.                 
  620.                 if strippedline == last:
  621.                     self.done = 1
  622.                     break
  623.                 
  624.             
  625.             last_line_lfend = line.endswith('\n')
  626.             continue
  627.             return None
  628.  
  629.     
  630.     def make_file(self, binary = None):
  631.         import tempfile as tempfile
  632.         return tempfile.TemporaryFile('w+b')
  633.  
  634.  
  635.  
  636. class FormContentDict(UserDict.UserDict):
  637.     
  638.     def __init__(self, environ = os.environ):
  639.         self.dict = self.data = parse(environ = environ)
  640.         self.query_string = environ['QUERY_STRING']
  641.  
  642.  
  643.  
  644. class SvFormContentDict(FormContentDict):
  645.     
  646.     def __getitem__(self, key):
  647.         if len(self.dict[key]) > 1:
  648.             raise IndexError, 'expecting a single value'
  649.         
  650.         return self.dict[key][0]
  651.  
  652.     
  653.     def getlist(self, key):
  654.         return self.dict[key]
  655.  
  656.     
  657.     def values(self):
  658.         result = []
  659.         for value in self.dict.values():
  660.             if len(value) == 1:
  661.                 result.append(value[0])
  662.                 continue
  663.             result.append(value)
  664.         
  665.         return result
  666.  
  667.     
  668.     def items(self):
  669.         result = []
  670.         for key, value in self.dict.items():
  671.             if len(value) == 1:
  672.                 result.append((key, value[0]))
  673.                 continue
  674.             result.append((key, value))
  675.         
  676.         return result
  677.  
  678.  
  679.  
  680. class InterpFormContentDict(SvFormContentDict):
  681.     
  682.     def __getitem__(self, key):
  683.         v = SvFormContentDict.__getitem__(self, key)
  684.         if v[0] in '0123456789+-.':
  685.             
  686.             try:
  687.                 return int(v)
  688.             except ValueError:
  689.                 
  690.                 try:
  691.                     return float(v)
  692.                 except ValueError:
  693.                     pass
  694.                 except:
  695.                     None<EXCEPTION MATCH>ValueError
  696.                 
  697.  
  698.                 None<EXCEPTION MATCH>ValueError
  699.             
  700.  
  701.         None<EXCEPTION MATCH>ValueError
  702.         return v.strip()
  703.  
  704.     
  705.     def values(self):
  706.         result = []
  707.         for key in self.keys():
  708.             
  709.             try:
  710.                 result.append(self[key])
  711.             continue
  712.             except IndexError:
  713.                 result.append(self.dict[key])
  714.                 continue
  715.             
  716.  
  717.         
  718.         return result
  719.  
  720.     
  721.     def items(self):
  722.         result = []
  723.         for key in self.keys():
  724.             
  725.             try:
  726.                 result.append((key, self[key]))
  727.             continue
  728.             except IndexError:
  729.                 result.append((key, self.dict[key]))
  730.                 continue
  731.             
  732.  
  733.         
  734.         return result
  735.  
  736.  
  737.  
  738. class FormContent(FormContentDict):
  739.     
  740.     def values(self, key):
  741.         if key in self.dict:
  742.             return self.dict[key]
  743.         else:
  744.             return None
  745.  
  746.     
  747.     def indexed_value(self, key, location):
  748.         if key in self.dict:
  749.             if len(self.dict[key]) > location:
  750.                 return self.dict[key][location]
  751.             else:
  752.                 return None
  753.         else:
  754.             return None
  755.  
  756.     
  757.     def value(self, key):
  758.         if key in self.dict:
  759.             return self.dict[key][0]
  760.         else:
  761.             return None
  762.  
  763.     
  764.     def length(self, key):
  765.         return len(self.dict[key])
  766.  
  767.     
  768.     def stripped(self, key):
  769.         if key in self.dict:
  770.             return self.dict[key][0].strip()
  771.         else:
  772.             return None
  773.  
  774.     
  775.     def pars(self):
  776.         return self.dict
  777.  
  778.  
  779.  
  780. def test(environ = os.environ):
  781.     global maxlen
  782.     print 'Content-type: text/html'
  783.     print 
  784.     sys.stderr = sys.stdout
  785.     
  786.     try:
  787.         form = FieldStorage()
  788.         print_directory()
  789.         print_arguments()
  790.         print_form(form)
  791.         print_environ(environ)
  792.         print_environ_usage()
  793.         
  794.         def f():
  795.             exec 'testing print_exception() -- <I>italics?</I>'
  796.  
  797.         
  798.         def g(f = f):
  799.             f()
  800.  
  801.         print '<H3>What follows is a test, not an actual exception:</H3>'
  802.         g()
  803.     except:
  804.         print_exception()
  805.  
  806.     print '<H1>Second try with a small maxlen...</H1>'
  807.     maxlen = 50
  808.     
  809.     try:
  810.         form = FieldStorage()
  811.         print_directory()
  812.         print_arguments()
  813.         print_form(form)
  814.         print_environ(environ)
  815.     except:
  816.         print_exception()
  817.  
  818.  
  819.  
  820. def print_exception(type = None, value = None, tb = None, limit = None):
  821.     if type is None:
  822.         (type, value, tb) = sys.exc_info()
  823.     
  824.     import traceback as traceback
  825.     print 
  826.     print '<H3>Traceback (most recent call last):</H3>'
  827.     list = traceback.format_tb(tb, limit) + traceback.format_exception_only(type, value)
  828.     print '<PRE>%s<B>%s</B></PRE>' % (escape(''.join(list[:-1])), escape(list[-1]))
  829.     del tb
  830.  
  831.  
  832. def print_environ(environ = os.environ):
  833.     keys = environ.keys()
  834.     keys.sort()
  835.     print 
  836.     print '<H3>Shell Environment:</H3>'
  837.     print '<DL>'
  838.     for key in keys:
  839.         print '<DT>', escape(key), '<DD>', escape(environ[key])
  840.     
  841.     print '</DL>'
  842.     print 
  843.  
  844.  
  845. def print_form(form):
  846.     keys = form.keys()
  847.     keys.sort()
  848.     print 
  849.     print '<H3>Form Contents:</H3>'
  850.     if not keys:
  851.         print '<P>No form fields.'
  852.     
  853.     print '<DL>'
  854.     for key in keys:
  855.         print '<DT>' + escape(key) + ':',
  856.         value = form[key]
  857.         print '<i>' + escape(repr(type(value))) + '</i>'
  858.         print '<DD>' + escape(repr(value))
  859.     
  860.     print '</DL>'
  861.     print 
  862.  
  863.  
  864. def print_directory():
  865.     print 
  866.     print '<H3>Current Working Directory:</H3>'
  867.     
  868.     try:
  869.         pwd = os.getcwd()
  870.     except os.error:
  871.         msg = None
  872.         print 'os.error:', escape(str(msg))
  873.  
  874.     print escape(pwd)
  875.     print 
  876.  
  877.  
  878. def print_arguments():
  879.     print 
  880.     print '<H3>Command Line Arguments:</H3>'
  881.     print 
  882.     print sys.argv
  883.     print 
  884.  
  885.  
  886. def print_environ_usage():
  887.     print '\n<H3>These environment variables could have been set:</H3>\n<UL>\n<LI>AUTH_TYPE\n<LI>CONTENT_LENGTH\n<LI>CONTENT_TYPE\n<LI>DATE_GMT\n<LI>DATE_LOCAL\n<LI>DOCUMENT_NAME\n<LI>DOCUMENT_ROOT\n<LI>DOCUMENT_URI\n<LI>GATEWAY_INTERFACE\n<LI>LAST_MODIFIED\n<LI>PATH\n<LI>PATH_INFO\n<LI>PATH_TRANSLATED\n<LI>QUERY_STRING\n<LI>REMOTE_ADDR\n<LI>REMOTE_HOST\n<LI>REMOTE_IDENT\n<LI>REMOTE_USER\n<LI>REQUEST_METHOD\n<LI>SCRIPT_NAME\n<LI>SERVER_NAME\n<LI>SERVER_PORT\n<LI>SERVER_PROTOCOL\n<LI>SERVER_ROOT\n<LI>SERVER_SOFTWARE\n</UL>\nIn addition, HTTP headers sent by the server may be passed in the\nenvironment as well.  Here are some common variable names:\n<UL>\n<LI>HTTP_ACCEPT\n<LI>HTTP_CONNECTION\n<LI>HTTP_HOST\n<LI>HTTP_PRAGMA\n<LI>HTTP_REFERER\n<LI>HTTP_USER_AGENT\n</UL>\n'
  888.  
  889.  
  890. def escape(s, quote = None):
  891.     s = s.replace('&', '&')
  892.     s = s.replace('<', '<')
  893.     s = s.replace('>', '>')
  894.     if quote:
  895.         s = s.replace('"', '"')
  896.     
  897.     return s
  898.  
  899.  
  900. def valid_boundary(s, _vb_pattern = '^[ -~]{0,200}[!-~]$'):
  901.     import re as re
  902.     return re.match(_vb_pattern, s)
  903.  
  904. if __name__ == '__main__':
  905.     test()
  906.  
  907.